package hr.utils;

import jakarta.servlet.http.HttpServletRequest;
import lombok.extern.slf4j.Slf4j;

import java.lang.reflect.InvocationTargetException;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.Enumeration;
import java.lang.reflect.Method;

/**
 * Description
 *
 * @author 卓子恒
 * @date: 2023/12/6 - 15:38
 * @apiNote
 */
@Slf4j
//@Component
public class CommonUtils {
//    @Autowired
//    private Environment environment;

    /**
     * 校验参数
     *
     * @param args
     * @return
     */
    public static boolean checkParams(String... args) {
        for (String arg : args) {
            if (arg.isBlank()) {
                return true;
            }
        }
        return false;
    }

    public static boolean checkParamsObj(Object... args) {
        if (args == null) {
            throw new NullPointerException("arg 参数为 null");
        }
        for (Object arg : args) {
            if (arg == null) {
                return true;
            }
        }
        return false;
    }

    public static String getIPAddress() {
        String localIp = null;
        try {
            Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();

            while (interfaces.hasMoreElements()) {
                NetworkInterface iface = interfaces.nextElement();

                // 过滤需要的网络接口，这里假设我们要找到WLAN接口
                if (iface.getName().startsWith("wlan")) {
                    Enumeration<InetAddress> addresses = iface.getInetAddresses();

                    while (addresses.hasMoreElements()) {
                        InetAddress addr = addresses.nextElement();

                        // 检查是否是IPv4地址
                        if (addr instanceof Inet4Address) {
                            log.info("IPv4地址:: {}", addr.getHostAddress());
                            localIp = addr.getHostAddress();
                        }
                    }
                }
            }
        } catch (SocketException e) {
            e.printStackTrace();
        }

        return localIp;
    }

    public static String getTokenFromReqHeaders(HttpServletRequest request) {
        // 获取请求头中的token
        String[] tokensParam = new String[]{"token", "Token", "Authorization"};
        String token = null;
        for (String key : tokensParam) {
            token = request.getHeader(key);
            if (token != null) {
                // 处理token
                token = token.replace("Bearer", "").trim();
                break;
            }
        }
        return token;
    }

    /**
     * 这个方法接受一个类，和这个类的class类型，从而获取所有的get方法，并且校验get方法获取的值是否合法，
     * 如果是字符串类型判断是否为空和null，如果是数值的包装类型则判断是否为null
     *
     * @param object
     * @param clazz
     */
    public static boolean checkObjField(Object object, Class<?> clazz) {
        Method[] methods = clazz.getMethods();

        for (Method method : methods) {
            if (isGetMethod(method)) {
                try {
                    Object value = method.invoke(object);
                    if (!validateValue(method.getName(), value)) {
                        return false;
                    }
                } catch (IllegalAccessException | InvocationTargetException e) {
                    e.printStackTrace();  // 处理异常，根据实际情况进行适当的处理
                }
            }
        }

        return true;
    }

    private static boolean isGetMethod(Method method) {
        return method.getName().startsWith("get") && method.getParameterCount() == 0;
    }

    private static boolean validateValue(String methodName, Object value) {
        if (value == null) {
            log.info("{}  返回null值。", methodName);
            return false;
        } else if (value instanceof String && ((String) value).isEmpty()) {
            log.info("{} 返回了一个空或null的字符串值。", methodName);
            return false;
        }
        return true;
    }

    // 将时间戳转换为年-月-日格式的字符串
    public static String convertTimestampToYMD(long timestamp) {
        Instant instant = Instant.ofEpochMilli(timestamp);
        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());

        // 定义日期时间格式
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

        // 格式化日期时间
        return localDateTime.format(formatter);
    }

    public static String convertTimestampToYMDAndTime(long timestamp) {
        // 将时间戳转换为 Instant 对象
        Instant instant = Instant.ofEpochMilli(timestamp);

        // 将 Instant 转换为 LocalDateTime 对象（本地时区）
        LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());

        // 定义日期时间格式
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        // 将 LocalDateTime 格式化为字符串
        String formattedDateTime = dateTime.format(formatter);

        return formattedDateTime;
    }

    // 将年-月-日 2023-01-01 格式的字符串转换为时间戳
    public static long convertYMDDateToTimestamp(String formattedDate) {
        if (formattedDate == null || formattedDate.isBlank()) return -1;

        // 假设你已经有了一个格式化后的日期时间字符串
        // String formattedDateTime = "2023-01-01 00:00:00";
        formattedDate += " 00:00:00";

        // 定义日期时间格式
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        // 将字符串解析为 LocalDateTime 对象
        LocalDateTime dateTime = LocalDateTime.parse(formattedDate, formatter);

        // 将 LocalDateTime 转换为 Instant 对象
        Instant instant = dateTime.atZone(ZoneId.systemDefault()).toInstant();

        // 将 Instant 转换为时间戳
        long timestamp = instant.toEpochMilli();

        return timestamp;
        // 打印时间戳
        // System.out.println(timestamp);
    }

    // 将2023-01-01 12:30:45格式的字符串转换为时间戳
    public static long convertYMDHMSDateToTimestamp(String formattedDateTime) {
        if (formattedDateTime == null || formattedDateTime.isBlank()) return -1;


        // 假设你已经有了一个格式化后的日期时间字符串
        // String formattedDateTime = "2023-01-01 12:30:45";

        // 定义日期时间格式
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        // 将字符串解析为 LocalDateTime 对象
        LocalDateTime dateTime = LocalDateTime.parse(formattedDateTime, formatter);

        // 将 LocalDateTime 转换为 Instant 对象
        Instant instant = dateTime.atZone(ZoneId.systemDefault()).toInstant();

        // 将 Instant 转换为时间戳
        long timestamp = instant.toEpochMilli();

        return timestamp;
        // 打印时间戳
        // System.out.println(timestamp);
    }
}
